Electronic data is typically secured using ‘open’ encryption. The current ‘open’ encryption standard is Public Key Infrastructure (PKI), which is built around two critical components:
1. Key-Pairs
A key-pair set is a pair of keys (an encryption key and a decryption key) that are mathematically bound to each other. Key-pair sets are most easily understood by comparing them to the electronic equivalent of a physical lock and key. The “Encryption Key” is like the lock—it is what makes the encrypted information secure from viewing by unauthorized parties. The “Decryption Key” is like a physical key, it allows you to open the lock and retrieve what is inside the package.
2. Public Storage of One Key
The “Encryption Key” (the digital ‘lock’) is stored in a public place, where anyone can pick it up and use it. This makes it easily available to all—akin to taking a physical lock off a shelf to secure an outside door. But in the digital realm, this availability/openness exposes and potentially renders vulnerable part of the security that is critical for secure communication between parties.
Iii an overly simplified example of this in action, a user places information e-commerce transaction, medical data transfer, wearables device data, etc.) into a box and secures it by retrieving the lock (“Encryption Key”) from a publicly available repository. Then he sends the locked box to the end user who uses his key (“Decryption Key”) to unlock the box and retrieve the information.
In reality, this process is far more complicated, but can be explained with the following algebraic equation:                Consider (AB) as the first user's key-pair: “A” is the lock and “B” is the key.        Consider (YZ) as the second user's key-pair: “Y” is the lock and “Z” is the key.        Both users have published their locks (A & Y) to a public repository so others can communicate with them securely.        The following are all true:        
      A    ≠    B    ≠    Y    ≠    Z              AB      YZ        ≠    1              BY      AZ        =    1                  Then mathematically the following is also true:        
                              BY                                      AZ                      ⁢          (      Data      )        =      (    Data    )  
The above equation shows the computation of the package (Data), illustrating its transition from one user to another.
The steps would occur this way:                1. Combine the first user's private key (B) and the second user's publicly available “lock” (Y) with the information to be sent (Data). This creates a locked package that is sent to the end user.BY(Data)        2. The end user takes the received package and applies its own private key (Z) and the first user's public key (A) retrieved from the repository.        
      BY    ⁡          (      Data      )        AZ                3. After applying the missing pieces (AZ) to the received package (BY(Data)) then the original data is revealed.        
The “Public Key” allows anyone to lock data in a way that only the recipient will be able to unlock. This feature is both a strength and weakness. It allows the locking piece to be used by anyone that wants to communicate securely. However, because it is publicly available, it also makes reverse engineering of the algorithm time consuming, but not impossible. If, one wants to derive another's private key, he can simply reverse engineer it with enough time and processor power. Given both, one may eventually extract (Z) from (BY(DATA))/A, since the public key (“A”) and data package (BY(Data)) are online for an infinite period of time. The solution to the above problems is to never share or publicly post a key-pair, or to have the key-pair changed for each and every transaction that is encrypted.